// test_category_apis.js - 测试视频类别相关API接口
const axios = require('axios');
const fs = require('fs');

// API基础URL
const BASE_URL = 'http://localhost:3000/api';

// 管理员账号信息
const ADMIN_USERNAME = 'admin';
const ADMIN_PASSWORD = '123456';

// 测试结果
const testResults = {
  timestamp: new Date().toISOString(),
  tests: [],
  summary: {
    total: 0,
    passed: 0,
    failed: 0
  }
};

// 管理员登录凭证（用于获取token）
let adminToken = null;

// 测试类别数据
const testCategoryData = {
  name: '测试类别' + Date.now(),
  alias: 'test-category-' + Date.now(),
  description: '这是一个测试类别',
  icon: 'fa-test',
  parent_id: null, // 使用JavaScript的null值表示顶级类别
  level: 1,
  sort_order: 100
};

// 创建的类别ID
let createdCategoryId = null;

/**
 * 记录测试结果
 * @param {string} name - 测试名称
 * @param {boolean} passed - 是否通过
 * @param {object} details - 测试详情
 */
function recordTestResult(name, passed, details = {}) {
  const result = {
    name,
    passed,
    timestamp: new Date().toISOString(),
    details
  };
  
  testResults.tests.push(result);
  testResults.summary.total++;
  if (passed) {
    testResults.summary.passed++;
  } else {
    testResults.summary.failed++;
  }
  
  console.log(`[${passed ? 'PASS' : 'FAIL'}] ${name}`);
  if (!passed && details.error) {
    console.error('  Error:', details.error);
  }
}

/**
 * 保存测试结果到文件
 */
function saveTestResults() {
  const fileName = 'category_test_results.json';
  fs.writeFileSync(fileName, JSON.stringify(testResults, null, 2));
  console.log(`\n测试结果已保存到 ${fileName}`);
  console.log(`总测试数: ${testResults.summary.total}`);
  console.log(`通过: ${testResults.summary.passed}`);
  console.log(`失败: ${testResults.summary.failed}`);
}

/**
 * 测试管理员登录（获取token）
 */
async function testAdminLogin() {
  try {
    const response = await axios.post(`${BASE_URL}/auth/login`, {
      username: ADMIN_USERNAME,
      password: ADMIN_PASSWORD
    });
    
    if (response.data && response.data.code === 200 && response.data.data && response.data.data.token) {
      adminToken = response.data.data.token;
      recordTestResult('管理员登录', true, { token: '已获取' });
      return true;
    } else {
      recordTestResult('管理员登录', false, { error: '登录失败，未返回有效token' });
      return false;
    }
  } catch (error) {
    recordTestResult('管理员登录', false, {
      error: error.response ? error.response.data : error.message
    });
    return false;
  }
}

/**
 * 测试获取所有启用的类别（公开接口）
 */
async function testGetAllCategories() {
  try {
    const response = await axios.get(`${BASE_URL}/categories`);
    
    if (response.status === 200 && response.data.code === 200) {
      recordTestResult('获取所有启用的类别', true, {
        dataLength: response.data.data ? response.data.data.length : 0
      });
      return true;
    } else {
      recordTestResult('获取所有启用的类别', false, {
        error: response.data ? response.data.message : '未知错误'
      });
      return false;
    }
  } catch (error) {
    recordTestResult('获取所有启用的类别', false, {
      error: error.response ? error.response.data : error.message
    });
    return false;
  }
}

/**
 * 测试创建类别（管理员接口）
 */
async function testCreateCategory() {
  if (!adminToken) {
    recordTestResult('创建类别', false, { error: '未获取到管理员token' });
    return false;
  }
  
  try {
    const response = await axios.post(
      `${BASE_URL}/categories`,
      testCategoryData,
      {
        headers: {
          Authorization: `Bearer ${adminToken}`
        }
      }
    );
    
    if (response.status === 201 && response.data.code === 201 && response.data.data) {
      createdCategoryId = response.data.data.id;
      recordTestResult('创建类别', true, {
        categoryId: createdCategoryId
      });
      return true;
    } else {
      recordTestResult('创建类别', false, {
        error: response.data ? response.data.message : '未知错误'
      });
      return false;
    }
  } catch (error) {
    recordTestResult('创建类别', false, {
      error: error.response ? error.response.data : error.message
    });
    return false;
  }
}

/**
 * 测试更新类别（管理员接口）
 */
async function testUpdateCategory() {
  if (!adminToken || !createdCategoryId) {
    recordTestResult('更新类别', false, { error: '未获取到管理员token或类别ID' });
    return false;
  }
  
  try {
    const updateData = {
      description: '这是更新后的测试类别描述',
      sortOrder: 50
    };
    
    const response = await axios.put(
      `${BASE_URL}/categories/${createdCategoryId}`,
      updateData,
      {
        headers: {
          Authorization: `Bearer ${adminToken}`
        }
      }
    );
    
    if (response.status === 200 && response.data.code === 200) {
      recordTestResult('更新类别', true, { categoryId: createdCategoryId });
      return true;
    } else {
      recordTestResult('更新类别', false, {
        error: response.data ? response.data.message : '未知错误'
      });
      return false;
    }
  } catch (error) {
    recordTestResult('更新类别', false, {
      error: error.response ? error.response.data : error.message
    });
    return false;
  }
}

/**
 * 测试获取类别详情（公开接口）
 */
async function testGetCategoryById() {
  if (!createdCategoryId) {
    recordTestResult('获取类别详情', false, { error: '未创建测试类别' });
    return false;
  }
  
  try {
    const response = await axios.get(`${BASE_URL}/categories/${createdCategoryId}`);
    
    if (response.status === 200 && response.data.code === 200) {
      recordTestResult('获取类别详情', true, { categoryId: createdCategoryId });
      return true;
    } else {
      recordTestResult('获取类别详情', false, {
        error: response.data ? response.data.message : '未知错误'
      });
      return false;
    }
  } catch (error) {
    recordTestResult('获取类别详情', false, {
      error: error.response ? error.response.data : error.message
    });
    return false;
  }
}

/**
 * 测试删除类别（管理员接口）
 */
async function testDeleteCategory() {
  if (!adminToken || !createdCategoryId) {
    recordTestResult('删除类别', false, { error: '未获取到管理员token或类别ID' });
    return false;
  }
  
  try {
    const response = await axios.delete(
      `${BASE_URL}/categories/${createdCategoryId}`,
      {
        headers: {
          Authorization: `Bearer ${adminToken}`
        }
      }
    );
    
    if (response.status === 200 && response.data.code === 200) {
      recordTestResult('删除类别', true, { categoryId: createdCategoryId });
      return true;
    } else {
      recordTestResult('删除类别', false, {
        error: response.data ? response.data.message : '未知错误'
      });
      return false;
    }
  } catch (error) {
    recordTestResult('删除类别', false, {
      error: error.response ? error.response.data : error.message
    });
    return false;
  }
}

/**
 * 测试未授权访问管理员接口
 */
async function testUnauthorizedAccess() {
  try {
    const response = await axios.post(`${BASE_URL}/categories`, testCategoryData);
    // 不应该成功，所以如果走到这里，测试失败
    recordTestResult('未授权访问管理员接口', false, { error: '应该返回401未授权错误' });
    return false;
  } catch (error) {
    if (error.response && error.response.status === 401) {
      recordTestResult('未授权访问管理员接口', true, { expected: '401未授权错误' });
      return true;
    } else {
      recordTestResult('未授权访问管理员接口', false, {
        error: `期望401错误，但得到了 ${error.response ? error.response.status : '未知错误'}`
      });
      return false;
    }
  }
}

/**
 * 主测试函数
 */
async function runTests() {
  console.log('开始测试视频类别API接口...');
  
  // 测试公开接口
  await testGetAllCategories();
  
  // 尝试管理员登录
  const loginSuccess = await testAdminLogin();
  
  // 如果登录成功，测试管理员接口
  if (loginSuccess) {
    // 测试创建类别
    const createSuccess = await testCreateCategory();
    
    if (createSuccess) {
      // 测试获取类别详情
      await testGetCategoryById();
      // 测试修改类别
      await testUpdateCategory();
      // 测试删除类别
      await testDeleteCategory();
    }
  }
  
  // 测试未授权访问
  await testUnauthorizedAccess();
  
  // 保存测试结果
  saveTestResults();
}

// 运行测试
runTests().catch(error => {
  console.error('测试过程中发生错误:', error);
  saveTestResults();
});